Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b3, i3)
START1(i) -> BUSY7(F, closed, stop, false, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b2, i2)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b1, i1)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b3, i3)
START1(i) -> BUSY7(F, closed, stop, false, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b2, i2)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> OR2(b1, i1)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 4 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
QDP
          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
BUSY7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> IDLE7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = max{0, -1}


POL( IDLE7(x1, ..., x7) ) = max{0, 2x7 - 2}


POL( or2(x1, x2) ) = 2


POL( BF ) = 2


POL( closed ) = 2


POL( F ) = max{0, -1}


POL( empty ) = max{0, -2}


POL( BUSY7(x1, ..., x7) ) = 2x7


POL( true ) = 2


POL( FS ) = 2


POL( open ) = 2


POL( false ) = 2


POL( stop ) = 1


POL( newbuttons4(x1, ..., x4) ) = x1 + 2x2 + x3 + x4 + 1


POL( up ) = 1


POL( S ) = 2


POL( B ) = 2



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
QDP
              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


IDLE7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> BUSY7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = max{0, -1}


POL( IDLE7(x1, ..., x7) ) = max{0, 2x7 - 2}


POL( or2(x1, x2) ) = 0


POL( BF ) = 2


POL( closed ) = 0


POL( F ) = 2


POL( empty ) = max{0, -2}


POL( BUSY7(x1, ..., x7) ) = 2x7


POL( true ) = 2


POL( FS ) = max{0, -1}


POL( open ) = 2


POL( false ) = max{0, -1}


POL( stop ) = 1


POL( newbuttons4(x1, ..., x4) ) = 2x3 + x4 + 2


POL( up ) = 2


POL( S ) = 2


POL( B ) = 2



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ QDPOrderProof
QDP
                  ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(S, d, stop, b1, b2, true, i) -> IDLE7(S, open, stop, b1, b2, false, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = 2


POL( IDLE7(x1, ..., x7) ) = x6 + 2x7 + 1


POL( BF ) = 2


POL( closed ) = 2


POL( empty ) = 1


POL( F ) = max{0, -2}


POL( BUSY7(x1, ..., x7) ) = x6 + 2x7 + 1


POL( FS ) = 1


POL( true ) = 1


POL( open ) = 2


POL( false ) = max{0, -1}


POL( stop ) = 0


POL( up ) = 2


POL( S ) = max{0, -1}


POL( B ) = 2



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ QDPOrderProof
QDP
                      ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(F, d, stop, b1, true, b3, i) -> IDLE7(F, open, stop, b1, false, b3, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = max{0, -2}


POL( IDLE7(x1, ..., x7) ) = 2x1 + 2x2 + 2x5 + 2


POL( BF ) = 2


POL( closed ) = 0


POL( empty ) = max{0, -1}


POL( F ) = 2


POL( BUSY7(x1, ..., x7) ) = 2x1 + 2x2 + 2x5 + x7 + 2


POL( FS ) = 2


POL( true ) = 2


POL( open ) = max{0, -2}


POL( false ) = max{0, -2}


POL( stop ) = 2


POL( up ) = 0


POL( S ) = 2


POL( B ) = 2



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ QDPOrderProof
                    ↳ QDP
                      ↳ QDPOrderProof
QDP
                          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(B, d, stop, true, b2, b3, i) -> IDLE7(B, open, stop, false, b2, b3, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = 2


POL( IDLE7(x1, ..., x7) ) = x2 + x4 + x5


POL( BF ) = 1


POL( closed ) = 0


POL( empty ) = 2


POL( F ) = 2


POL( BUSY7(x1, ..., x7) ) = x4 + x5


POL( FS ) = 2


POL( true ) = 2


POL( open ) = 1


POL( false ) = max{0, -2}


POL( stop ) = 0


POL( up ) = 2


POL( S ) = 2


POL( B ) = max{0, -2}



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ QDPOrderProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ QDPOrderProof
QDP
                              ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


BUSY7(B, open, stop, false, b2, b3, i) -> IDLE7(B, closed, stop, false, b2, b3, i)
BUSY7(F, open, stop, b1, false, b3, i) -> IDLE7(F, closed, stop, b1, false, b3, i)
BUSY7(S, open, stop, b1, b2, false, i) -> IDLE7(S, closed, stop, b1, b2, false, i)
The remaining pairs can at least be oriented weakly.

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( down ) = 2


POL( IDLE7(x1, ..., x7) ) = max{0, x2 + x4 + 2x7 - 1}


POL( BF ) = 1


POL( closed ) = 1


POL( empty ) = 1


POL( F ) = 1


POL( BUSY7(x1, ..., x7) ) = max{0, x2 + x4 + 2x7 - 1}


POL( true ) = 1


POL( FS ) = max{0, -1}


POL( open ) = 2


POL( false ) = 1


POL( stop ) = 2


POL( up ) = 2


POL( S ) = 2


POL( B ) = 2



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ QDP
          ↳ QDPOrderProof
            ↳ QDP
              ↳ QDPOrderProof
                ↳ QDP
                  ↳ QDPOrderProof
                    ↳ QDP
                      ↳ QDPOrderProof
                        ↳ QDP
                          ↳ QDPOrderProof
                            ↳ QDP
                              ↳ QDPOrderProof
QDP

Q DP problem:
The TRS P consists of the following rules:

BUSY7(S, closed, stop, true, false, false, i) -> IDLE7(S, closed, down, true, false, false, i)
BUSY7(F, closed, down, b1, false, b3, i) -> IDLE7(BF, closed, down, b1, false, b3, i)
BUSY7(B, closed, stop, false, false, true, i) -> IDLE7(B, closed, up, false, false, true, i)
BUSY7(FS, closed, down, b1, b2, b3, i) -> IDLE7(F, closed, down, b1, b2, b3, i)
BUSY7(S, closed, down, b1, b2, true, i) -> IDLE7(S, closed, stop, b1, b2, true, i)
BUSY7(F, closed, up, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
BUSY7(S, closed, stop, b1, true, false, i) -> IDLE7(S, closed, down, b1, true, false, i)
BUSY7(F, closed, up, b1, false, b3, i) -> IDLE7(FS, closed, up, b1, false, b3, i)
BUSY7(F, closed, stop, true, false, b3, i) -> IDLE7(F, closed, down, true, false, b3, i)
BUSY7(B, closed, stop, false, true, b3, i) -> IDLE7(B, closed, up, false, true, b3, i)
BUSY7(F, closed, stop, false, false, true, i) -> IDLE7(F, closed, up, false, false, true, i)
BUSY7(BF, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, down, b1, b2, b3, i)
BUSY7(F, closed, down, b1, true, b3, i) -> IDLE7(F, closed, stop, b1, true, b3, i)
IDLE7(fl, d, m, b1, b2, b3, empty) -> BUSY7(fl, d, m, b1, b2, b3, empty)
BUSY7(BF, closed, up, b1, b2, b3, i) -> IDLE7(F, closed, up, b1, b2, b3, i)
BUSY7(S, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, stop, b1, b2, b3, i)
BUSY7(B, closed, up, false, b2, b3, i) -> IDLE7(BF, closed, up, false, b2, b3, i)
BUSY7(S, closed, down, b1, b2, false, i) -> IDLE7(FS, closed, down, b1, b2, false, i)
BUSY7(B, closed, up, true, b2, b3, i) -> IDLE7(B, closed, stop, true, b2, b3, i)
BUSY7(FS, closed, up, b1, b2, b3, i) -> IDLE7(S, closed, up, b1, b2, b3, i)
BUSY7(B, closed, down, b1, b2, b3, i) -> IDLE7(B, closed, stop, b1, b2, b3, i)

The TRS R consists of the following rules:

start1(i) -> busy7(F, closed, stop, false, false, false, i)
busy7(BF, d, stop, b1, b2, b3, i) -> incorrect
busy7(FS, d, stop, b1, b2, b3, i) -> incorrect
busy7(fl, open, up, b1, b2, b3, i) -> incorrect
busy7(fl, open, down, b1, b2, b3, i) -> incorrect
busy7(B, closed, stop, false, false, false, empty) -> correct
busy7(F, closed, stop, false, false, false, empty) -> correct
busy7(S, closed, stop, false, false, false, empty) -> correct
busy7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(B, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(F, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i)) -> idle7(S, closed, stop, false, false, false, newbuttons4(i1, i2, i3, i))
busy7(B, open, stop, false, b2, b3, i) -> idle7(B, closed, stop, false, b2, b3, i)
busy7(F, open, stop, b1, false, b3, i) -> idle7(F, closed, stop, b1, false, b3, i)
busy7(S, open, stop, b1, b2, false, i) -> idle7(S, closed, stop, b1, b2, false, i)
busy7(B, d, stop, true, b2, b3, i) -> idle7(B, open, stop, false, b2, b3, i)
busy7(F, d, stop, b1, true, b3, i) -> idle7(F, open, stop, b1, false, b3, i)
busy7(S, d, stop, b1, b2, true, i) -> idle7(S, open, stop, b1, b2, false, i)
busy7(B, closed, down, b1, b2, b3, i) -> idle7(B, closed, stop, b1, b2, b3, i)
busy7(S, closed, up, b1, b2, b3, i) -> idle7(S, closed, stop, b1, b2, b3, i)
busy7(B, closed, up, true, b2, b3, i) -> idle7(B, closed, stop, true, b2, b3, i)
busy7(F, closed, up, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(F, closed, down, b1, true, b3, i) -> idle7(F, closed, stop, b1, true, b3, i)
busy7(S, closed, down, b1, b2, true, i) -> idle7(S, closed, stop, b1, b2, true, i)
busy7(B, closed, up, false, b2, b3, i) -> idle7(BF, closed, up, false, b2, b3, i)
busy7(F, closed, up, b1, false, b3, i) -> idle7(FS, closed, up, b1, false, b3, i)
busy7(F, closed, down, b1, false, b3, i) -> idle7(BF, closed, down, b1, false, b3, i)
busy7(S, closed, down, b1, b2, false, i) -> idle7(FS, closed, down, b1, b2, false, i)
busy7(BF, closed, up, b1, b2, b3, i) -> idle7(F, closed, up, b1, b2, b3, i)
busy7(BF, closed, down, b1, b2, b3, i) -> idle7(B, closed, down, b1, b2, b3, i)
busy7(FS, closed, up, b1, b2, b3, i) -> idle7(S, closed, up, b1, b2, b3, i)
busy7(FS, closed, down, b1, b2, b3, i) -> idle7(F, closed, down, b1, b2, b3, i)
busy7(B, closed, stop, false, true, b3, i) -> idle7(B, closed, up, false, true, b3, i)
busy7(B, closed, stop, false, false, true, i) -> idle7(B, closed, up, false, false, true, i)
busy7(F, closed, stop, true, false, b3, i) -> idle7(F, closed, down, true, false, b3, i)
busy7(F, closed, stop, false, false, true, i) -> idle7(F, closed, up, false, false, true, i)
busy7(S, closed, stop, b1, true, false, i) -> idle7(S, closed, down, b1, true, false, i)
busy7(S, closed, stop, true, false, false, i) -> idle7(S, closed, down, true, false, false, i)
idle7(fl, d, m, b1, b2, b3, empty) -> busy7(fl, d, m, b1, b2, b3, empty)
idle7(fl, d, m, b1, b2, b3, newbuttons4(i1, i2, i3, i)) -> busy7(fl, d, m, or2(b1, i1), or2(b2, i2), or2(b3, i3), i)
or2(true, b) -> true
or2(false, b) -> b

Q is empty.
We have to consider all minimal (P,Q,R)-chains.